home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / gdb / gdb_18s.zoo / fake / console.c next >
C/C++ Source or Header  |  1992-03-28  |  4KB  |  210 lines

  1. /* 
  2.  * console input/output routines.
  3.  * written by Eric R. Smith and placed in the public domain
  4.  */
  5.  
  6. /*
  7.  * BUGS: assumes that all tty handles >= 0 are console handles.
  8.  * If we have some handles >= 0 not attached to the console,
  9.  * and some other handles attached to a different device, we might
  10.  * get characters mixed up. This will generally not be a problem,
  11.  * since earlier versions of the library forbid any non-console
  12.  * devices entirely.
  13.  */
  14.  
  15. #include <osbind.h>
  16. #include <support.h>
  17. #include <stdlib.h>
  18. #include <ioctl.h>
  19. #include <tchars.h>
  20. #include <signal.h>
  21. #include <unistd.h>
  22. #ifndef _COMPILER_H
  23. #include <compiler.h>
  24. #endif
  25.  
  26. extern int _console_dev;    /* in main.c */
  27. int __check_signals = 0;
  28.  
  29. #define KBUFSIZ 80
  30. #define NUMDEV    3
  31.     /* 0 == prn:, 1 == aux:, 2 == con: */
  32.  
  33. typedef struct _buffer {
  34.     short head, tail;
  35.     long  buffer[KBUFSIZ];
  36. } k_buf;
  37.  
  38. k_buf in_buf[NUMDEV];
  39. #define IN_BUF(dev) (&in_buf[(dev) > 2 ? _console_dev : (dev)])
  40.  
  41. /*
  42.  * what handle means:: 0-2: BIOS handle, 3: stdout, 4: stderr
  43.  */
  44. static short LOOKUP __PROTO((short handle));
  45. static long raw_in __PROTO((int dev));
  46. static long raw_instat __PROTO((int dev));
  47. #if 0
  48. static void raw_out __PROTO((int dev, int c));
  49. #endif
  50.  
  51. static short
  52. #ifdef __STDC__
  53. LOOKUP(short handle)
  54. #else
  55. LOOKUP(handle)
  56. short handle;
  57. #endif
  58. {
  59.     switch(handle) {
  60.     case -3:
  61.     case -2:
  62.     case -1:
  63.     case 0:
  64.         return handle + 3;
  65.     case 2:
  66.         return 4;
  67.     case 1:
  68.         if (isatty(0)) return 3;
  69.         if (isatty(2)) return 4;
  70.         /* else fall through */
  71.     default:
  72.         return _console_dev;
  73.     }
  74. }
  75.  
  76. /*
  77.  * raw i/o routines
  78.  */
  79.  
  80. static long
  81. raw_in(dev)
  82. int dev;
  83. {
  84.     if (dev < 3)
  85.         return Bconin(dev);
  86.     else if (dev == 3)
  87.         return Crawcin();
  88.     else
  89.         return Cauxin();
  90. }
  91.  
  92. #if 0
  93. static void
  94. raw_out(dev, c)
  95. int dev, c;
  96. {
  97.     if (dev < 3)
  98.         Bconout(dev, c);
  99.     else if (dev == 3)
  100.         (void)Crawio(c);
  101.     else
  102.         Cauxout(c);
  103. }
  104. #endif
  105.  
  106. static long
  107. raw_instat(dev)
  108. int dev;
  109. {
  110.     if (dev < 3)
  111.         return Bconstat(dev);
  112.     else if (dev == 3)
  113.         return Cconis();
  114.     else
  115.         return Cauxis();
  116. }
  117.  
  118. /*
  119.  * somewhat less raw i/o routines. The main difference is that these ones
  120.  * will check for pending input before doing output, to see if a signal
  121.  * needs to be raised. This is only done if __check_signals is non-zero;
  122.  * signal() should set __check_signals when the user attempts to catch
  123.  * SIGINT or SIGQUIT. We don't do this checking all the time because
  124.  * the user may be typing ahead input for another program (e.g. if this
  125.  * is a little utility of some sort) and we shouldn't steal keystrokes
  126.  * unless necessary.
  127.  */
  128.  
  129. unsigned int console_read_byte(handle)
  130. int handle;
  131. {
  132.     k_buf *p;
  133.     short i, j, dev;
  134.     long r;
  135.  
  136.     dev = LOOKUP(handle);
  137.  
  138.     p = IN_BUF(dev);
  139.     if ( p->head != (i = p->tail)) {
  140.         j = p->tail + 1;
  141.         if (j >= KBUFSIZ)
  142.             j = 0;
  143.         p->tail = j;
  144.         r = p->buffer[i];
  145.     }
  146.     else
  147.         r = raw_in(dev);
  148.  
  149.     return r;
  150. }
  151.  
  152. int console_input_status(handle)
  153. int handle;
  154. {
  155.     short dev;
  156.     k_buf *p;
  157.  
  158.     dev = LOOKUP(handle);
  159.     p = IN_BUF(dev);
  160.     return (p->head != p->tail) || raw_instat(dev);
  161. }
  162.  
  163. void
  164. console_write_byte(handle, n)
  165. int handle;
  166. int n;
  167. {
  168.     long c;
  169.     short i, j, waiting = 0;
  170.     char ch;
  171.     k_buf *p;
  172.     short dev;
  173.  
  174.     dev = LOOKUP(handle);
  175.     p = IN_BUF(dev);
  176.  
  177.     while (__check_signals && (raw_instat(dev) || waiting)) {
  178.         c = raw_in(dev);
  179.         if (!(__ttymode & RAW)) {
  180.             ch = c & 0xff;
  181.             if (ch == ('S'-'@')) {
  182.                 waiting = 1;
  183.             }
  184.             else if (ch == ('Q'-'@')) {
  185.                 waiting = 0;
  186.             }
  187.             else if (ch == __tchars[TC_INTRC]) {
  188.                 p->head = p->tail;
  189.                 raise(SIGINT);
  190.             }
  191.             else if (ch == __tchars[TC_QUITC]) {
  192.                 p->head = p->tail;
  193.                 raise(SIGQUIT);
  194.             }
  195.             else if (!waiting) {
  196.                 i = p->head;
  197.                 j = i + 1;
  198.                 if (j >= KBUFSIZ) j = 0;
  199.                 if (j != p->tail) {
  200.                     p->buffer[i] = c;
  201.                     p->head = j;
  202.                 }
  203.             }
  204.         }
  205.     }
  206. /*    raw_out(dev, n); */
  207.     ch = n;
  208.     (void)Fwrite(handle, 1L, &ch);
  209. }
  210.